home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / compile_to_c10.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  36.9 KB  |  1,646 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "compile_to_c.h"
  10. int rT112is_a(/*C*/T0 * a1){
  11. int R=0;
  12. R=1;
  13. return R;
  14. }
  15. void rT112expanded_to_reference(T112 *C){
  16. /*IF*/if (((T0 *)rT112run_type(C))!=((T0 *)C)) {
  17. XrT58expanded_to_reference(rT112run_type(C));
  18. }
  19. /*AF*//*FI*/}
  20. int rT112has_creation(T112 *C,T0 * a1){
  21. int R=0;
  22. /*UT*/(T45*)oRBC27eh;
  23. rT45add_position(XrT67start_position(a1));
  24. rT112error(rT112start_position(C),(T0 *)ms1493);
  25. return R;
  26. }
  27. void rT112make(T112 *C,T0 * a1){
  28. {T48 *n=((T48*)new(48));
  29. rT48make(n,(T0 *)ms185,a1);
  30. C->_base_class_name=(T0 *)n;}
  31. }
  32. void rT112c_type_in(/*C*/T0* a1){
  33. }
  34. void rT113fatal_error(/*C*/T0* a1){
  35. rT45fatal_error((T45*)oRBC27eh,a1);
  36. }
  37. void rT113cast_to_ref(T113 *C){
  38. XrT58cast_to_ref(rT113run_type(C));
  39. }
  40. T0* rT113generic_list(T113 *C){
  41. T0* R=NULL;
  42. /*UT*/(T45*)oRBC27eh;
  43. rT45add_type((T0 *)C,(T0 *)ms1437);
  44. rT45print_as_fatal_error((T45*)oRBC27eh);
  45. return R;
  46. }
  47. T0 * rT113look_up_for(T113 *C,T0 * a1,T0 * a2){
  48. T0 * R=NULL;
  49. T0 * _bc=NULL;
  50. _bc=rT113base_class(C);
  51. /*IF*/if (((int)_bc)) {
  52. R=rT50look_up_for((T50*)_bc,a1,a2);
  53. }
  54. else {
  55. /*UT*/(T45*)oRBC27eh;
  56. rT45append((T0 *)ms481);
  57. /*UT*/(T45*)oRBC27eh;
  58. rT45add_type((T0 *)C,(T0 *)ms38);
  59. rT45print_as_error((T45*)oRBC27eh);
  60. }
  61. /*FI*/return R;
  62. }
  63. T0 * rT113run_class(T113 *C){
  64. T0 * R=NULL;
  65. R=(/*UT*/(T52*)oRBC27small_eiffel,
  66. rT52run_class(rT113run_type(C)));
  67. return R;
  68. }
  69. void rT113mapping_c_in(/*C*/T0* a1){
  70. rT7append((T7*)a1,(T0 *)ms1464);
  71. }
  72. T0 * rT113smallest_ancestor(T113 *C,T0 * a1){
  73. T0 * R=NULL;
  74. R=(T0 *)C;
  75. return R;
  76. }
  77. void rT113expanded_to_reference(T113 *C){
  78. /*IF*/if (((T0 *)rT113run_type(C))!=((T0 *)C)) {
  79. XrT58expanded_to_reference(rT113run_type(C));
  80. }
  81.  else {/*AT*//*UT*/(T45*)oRBC27eh;
  82. rT45add_type((T0 *)C,(T0 *)ms1007);
  83. rT113fatal_error((T0 *)ms1008);
  84. }
  85. /*FI*/}
  86. int rT113is_a(T113 *C,T0 * a1){
  87. int R=0;
  88. /*IF*/if (XrT58is_pointer(a1)) {
  89. R=1;
  90. }
  91. else {
  92. /*UT*/(T45*)oRBC27eh;
  93. rT45add_type((T0 *)C,(T0 *)ms1487);
  94. /*UT*/(T45*)oRBC27eh;
  95. rT45add_type(a1,(T0 *)ms38);
  96. }
  97. /*FI*/return R;
  98. }
  99. void rT113make(T113 *C,T0 * a1){
  100. {T48 *n=((T48*)new(48));
  101. rT48make(n,(T0 *)ms186,a1);
  102. C->_base_class_name=(T0 *)n;}
  103. }
  104. void rT113c_type_in(T113 *C,T0* a1){
  105. rT7append((T7*)a1,(C)->_c_type);
  106. }
  107. T0 * rT113run_type(T113 *C){
  108. T0 * R=NULL;
  109. R=(T0 *)C;
  110. return R;
  111. }
  112. T0 * rT113to_runnable(T113 *C,T0 * a1){
  113. T0 * R=NULL;
  114. T0* _bcw=NULL;
  115. rT113check_type(C);
  116. R=(T0 *)C;
  117. _bcw=((T48*)((T46*)rT113start_position(C))->_base_class_name)->_to_string;
  118. /*IF*/if ((((T0 *)_bcw)==((T0 *)(T0 *)ms187))||(((T0 *)_bcw)==((T0 *)(T0 *)ms193))) {
  119. {T7 *n=((T7*)new(7));
  120. rT7make(n,8);
  121. C->_c_type=(T0 *)n;}
  122. XrT58c_type_in(rT106item((T106*)XrT58generic_list(a1),1),(C)->_c_type);
  123. rT7extend((T7*)(C)->_c_type,'\52');
  124. }
  125.  else if (((T0 *)_bcw)==((T0 *)(T0 *)ms188)) {
  126. C->_c_type=(T0 *)ms1453;
  127. }
  128. else {
  129. C->_c_type=(T0 *)ms1454;
  130. }
  131. /*FI*/return R;
  132. }
  133. void rT113error(/*C*/T0 * a1,T0* a2){
  134. /*UT*/(T45*)oRBC27eh;
  135. rT45add_position(a1);
  136. rT45error((T45*)oRBC27eh,a2);
  137. }
  138. T0 * rT113start_position(T113 *C){
  139. T0 * R=NULL;
  140. R=((T48*)(C)->_base_class_name)->_start_position;
  141. return R;
  142. }
  143. T0 * rT113base_class(T113 *C){
  144. T0 * R=NULL;
  145. R=rT48base_class((T48*)(C)->_base_class_name);
  146. return R;
  147. }
  148. int rT113is_a_in(T113 *C,T0 * a1,T0 * a2){
  149. int R=0;
  150. T0 * _ct=NULL;
  151. T0 * _t2=NULL;
  152. T0 * _t1=NULL;
  153. /*IF*/if (rT7is_equal((T7*)/*(IRF4*/(T0 *)ms186/*)*/,XrT58written_mark(a1))) {
  154. R=1;
  155. }
  156. else {
  157. _ct=((T260*)a2)->_current_type;
  158. _t1=rT113to_runnable(C,_ct);
  159. _t2=XrT58to_runnable(a1,_ct);
  160. /*IF*/if (rT7is_equal((T7*)XrT58run_time_mark(_t1),XrT58run_time_mark(_t2))) {
  161. R=1;
  162. }
  163. else {
  164. R=XrT58is_a(_t1,_t2);
  165. }
  166. /*FI*/}
  167. /*FI*/return R;
  168. }
  169. void rT113copy(T113 *C,T0 * a1){
  170. /*IF*//*AF*//*AE*/
  171. memcpy(C,a1,s[C->id]);
  172. /*FI*/}
  173. int ofBC113check_type=0;
  174. void rT113check_type(T113 *C){
  175. T0 * _rc=NULL;
  176. T0 * _bc=NULL;
  177. if (ofBC113check_type==0){
  178. ofBC113check_type=1;
  179. _bc=rT113base_class(C);
  180. /*IF*/if (!(_bc)) {
  181. rT113error(rT113start_position(C),(T0 *)ms1451);
  182. }
  183. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  184. _rc=rT113run_class(C);
  185. }
  186. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  187. /*IF*/if (!(((T50*)_bc)->_is_expanded)) {
  188. rT113error(rT113start_position(C),(T0 *)ms1452);
  189. }
  190. /*FI*/}
  191. /*FI*/}
  192. }
  193. int rT113has_creation(T113 *C,T0 * a1){
  194. int R=0;
  195. /*UT*/(T45*)oRBC27eh;
  196. rT45add_position(XrT67start_position(a1));
  197. rT113error(rT113start_position(C),(T0 *)ms1494);
  198. return R;
  199. }
  200. void rT114fatal_error(/*C*/T0* a1){
  201. rT45fatal_error((T45*)oRBC27eh,a1);
  202. }
  203. int ofBC114used_as_reference=0;
  204. void rT114used_as_reference(/*C*/void){
  205. if (ofBC114used_as_reference==0){
  206. ofBC114used_as_reference=1;
  207. rT114load_ref((T0 *)ms197);
  208. }
  209. }
  210. T0* rT114generic_list(T114 *C){
  211. T0* R=NULL;
  212. /*UT*/(T45*)oRBC27eh;
  213. rT45add_type((T0 *)C,(T0 *)ms1437);
  214. rT45print_as_fatal_error((T45*)oRBC27eh);
  215. return R;
  216. }
  217. T0 * rT114look_up_for(T114 *C,T0 * a1,T0 * a2){
  218. T0 * R=NULL;
  219. T0 * _bc=NULL;
  220. _bc=rT114base_class(C);
  221. /*IF*/if (((int)_bc)) {
  222. R=rT50look_up_for((T50*)_bc,a1,a2);
  223. }
  224. else {
  225. /*UT*/(T45*)oRBC27eh;
  226. rT45append((T0 *)ms481);
  227. /*UT*/(T45*)oRBC27eh;
  228. rT45add_type((T0 *)C,(T0 *)ms38);
  229. rT45print_as_error((T45*)oRBC27eh);
  230. }
  231. /*FI*/return R;
  232. }
  233. T0 * rT114run_class(T114 *C){
  234. T0 * R=NULL;
  235. R=(/*UT*/(T52*)oRBC27small_eiffel,
  236. rT52run_class(rT114run_type(C)));
  237. return R;
  238. }
  239. void rT114mapping_c_in(/*C*/T0* a1){
  240. rT7extend((T7*)a1,'T');
  241. rT2append_in(/*(IRF4*/4/*)*/,a1);
  242. }
  243. T0 * rT114smallest_ancestor(T114 *C,T0 * a1){
  244. T0 * R=NULL;
  245. T0 * _rto=NULL;
  246. _rto=XrT58run_type(a1);
  247. /*IF*/if (XrT58is_integer(_rto)) {
  248. R=(T0 *)C;
  249. }
  250.  else if (XrT58is_real(_rto)) {
  251. R=(T0 *)C;
  252. }
  253.  else if (XrT58is_double(_rto)) {
  254. R=a1;
  255. }
  256.  else if (XrT58is_reference(_rto)) {
  257. R=rT116smallest_ancestor((T116*)rT114type_real_ref(),a1);
  258. }
  259. else {
  260. rT114fatal_error((T0 *)ms1474);
  261. }
  262. /*FI*/return R;
  263. }
  264. void rT114expanded_to_reference(T114 *C){
  265. rT40conversion((T40*)oRBC27cpp,(T0 *)C,rT114type_real_ref());
  266. }
  267. int rT114is_a(T114 *C,T0 * a1){
  268. int R=0;
  269. /*IF*/if ((XrT58is_real(a1))||(XrT58is_double(a1))) {
  270. R=1;
  271. }
  272. else {
  273. R=rT50is_subclass_of((T50*)rT114base_class(C),XrT58base_class(a1));
  274. }
  275. /*FI*//*IF*/if (!(R)) {
  276. /*UT*/(T45*)oRBC27eh;
  277. rT45add_type((T0 *)C,(T0 *)ms1483);
  278. /*UT*/(T45*)oRBC27eh;
  279. rT45add_type(a1,(T0 *)ms38);
  280. }
  281. /*FI*/return R;
  282. }
  283. void rT114make(T114 *C,T0 * a1){
  284. {T48 *n=((T48*)new(48));
  285. rT48make(n,(T0 *)ms196,a1);
  286. C->_base_class_name=(T0 *)n;}
  287. }
  288. void rT114c_type_in(/*C*/T0* a1){
  289. rT7append((T7*)a1,(T0 *)ms1500);
  290. }
  291. int ofBC27type_real_ref=0;
  292. T0*oRBC27type_real_ref;
  293. T0 * rT114type_real_ref(/*C*/void){
  294. T0 * R=NULL;
  295. T0 * _real_ref=NULL;
  296. if (ofBC27type_real_ref==0){
  297. ofBC27type_real_ref=1;
  298. {T48 *n=((T48*)new(48));
  299. rT48make(n,(T0 *)ms197,NULL);
  300. _real_ref=(T0 *)n;}
  301. {T116 *n=((T116*)new(116));
  302. /*(IRF3*/((n)->_base_class_name)=(_real_ref);
  303. /*)*/R=(T0 *)n;}
  304. oRBC27type_real_ref=R;}
  305. return oRBC27type_real_ref;}
  306. T0 * rT114run_type(T114 *C){
  307. T0 * R=NULL;
  308. R=(T0 *)C;
  309. return R;
  310. }
  311. T0 * rT114to_runnable(T114 *C,T0 * a1){
  312. T0 * R=NULL;
  313. R=(T0 *)C;
  314. rT114check_type(C);
  315. return R;
  316. }
  317. void rT114error(/*C*/T0 * a1,T0* a2){
  318. /*UT*/(T45*)oRBC27eh;
  319. rT45add_position(a1);
  320. rT45error((T45*)oRBC27eh,a2);
  321. }
  322. T0 * rT114start_position(T114 *C){
  323. T0 * R=NULL;
  324. R=((T48*)(C)->_base_class_name)->_start_position;
  325. return R;
  326. }
  327. T0 * rT114base_class(T114 *C){
  328. T0 * R=NULL;
  329. R=rT48base_class((T48*)(C)->_base_class_name);
  330. return R;
  331. }
  332. int rT114is_a_in(T114 *C,T0 * a1,T0 * a2){
  333. int R=0;
  334. T0 * _ct=NULL;
  335. T0 * _t2=NULL;
  336. T0 * _t1=NULL;
  337. /*IF*/if (rT7is_equal((T7*)/*(IRF4*/(T0 *)ms196/*)*/,XrT58written_mark(a1))) {
  338. R=1;
  339. }
  340. else {
  341. _ct=((T260*)a2)->_current_type;
  342. _t1=rT114to_runnable(C,_ct);
  343. _t2=XrT58to_runnable(a1,_ct);
  344. /*IF*/if (rT7is_equal((T7*)XrT58run_time_mark(_t1),XrT58run_time_mark(_t2))) {
  345. R=1;
  346. }
  347. else {
  348. R=XrT58is_a(_t1,_t2);
  349. }
  350. /*FI*/}
  351. /*FI*/return R;
  352. }
  353. void rT114copy(T114 *C,T0 * a1){
  354. /*IF*//*AF*//*AE*/
  355. memcpy(C,a1,s[C->id]);
  356. /*FI*/}
  357. int ofBC114check_type=0;
  358. void rT114check_type(T114 *C){
  359. T0 * _rc=NULL;
  360. T0 * _bc=NULL;
  361. if (ofBC114check_type==0){
  362. ofBC114check_type=1;
  363. _bc=rT114base_class(C);
  364. /*IF*/if (!(_bc)) {
  365. rT114error(rT114start_position(C),(T0 *)ms1455);
  366. }
  367. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  368. _rc=rT114run_class(C);
  369. }
  370. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  371. /*IF*/if (!(((T50*)_bc)->_is_expanded)) {
  372. rT114error(rT114start_position(C),(T0 *)ms1456);
  373. }
  374. /*FI*/}
  375. /*FI*/}
  376. }
  377. int rT114has_creation(T114 *C,T0 * a1){
  378. int R=0;
  379. /*UT*/(T45*)oRBC27eh;
  380. rT45add_position(XrT67start_position(a1));
  381. rT114error(rT114start_position(C),(T0 *)ms1492);
  382. return R;
  383. }
  384. void rT114load_ref(/*C*/T0* a1){
  385. T0 * _rf=NULL;
  386. T0 * _rc=NULL;
  387. T0 * _cn=NULL;
  388. {T48 *n=((T48*)new(48));
  389. rT48make(n,a1,NULL);
  390. _cn=(T0 *)n;}
  391. _rc=rT50run_class((T50*)rT48base_class((T48*)_cn));
  392. rT260set_at_run_time((T260*)_rc);
  393. _rf=rT260get_feature_with((T260*)_rc,(T0 *)ms1462);
  394. }
  395. void rT115fatal_error(/*C*/T0* a1){
  396. rT45fatal_error((T45*)oRBC27eh,a1);
  397. }
  398. T0 * rT115run_type(T115 *C){
  399. T0 * R=NULL;
  400. R=(T0 *)C;
  401. return R;
  402. }
  403. T0 * rT115to_runnable(T115 *C,T0 * a1){
  404. T0 * R=NULL;
  405. R=(T0 *)C;
  406. rT115check_type(C);
  407. return R;
  408. }
  409. void rT115cast_to_ref(T115 *C){
  410. XrT58cast_to_ref(rT115run_type(C));
  411. }
  412. void rT115error(/*C*/T0 * a1,T0* a2){
  413. /*UT*/(T45*)oRBC27eh;
  414. rT45add_position(a1);
  415. rT45error((T45*)oRBC27eh,a2);
  416. }
  417. T0 * rT115start_position(T115 *C){
  418. T0 * R=NULL;
  419. R=((T48*)(C)->_base_class_name)->_start_position;
  420. return R;
  421. }
  422. T0* rT115generic_list(T115 *C){
  423. T0* R=NULL;
  424. /*UT*/(T45*)oRBC27eh;
  425. rT45add_type((T0 *)C,(T0 *)ms1437);
  426. rT45print_as_fatal_error((T45*)oRBC27eh);
  427. return R;
  428. }
  429. T0 * rT115look_up_for(T115 *C,T0 * a1,T0 * a2){
  430. T0 * R=NULL;
  431. T0 * _bc=NULL;
  432. _bc=rT115base_class(C);
  433. /*IF*/if (((int)_bc)) {
  434. R=rT50look_up_for((T50*)_bc,a1,a2);
  435. }
  436. else {
  437. /*UT*/(T45*)oRBC27eh;
  438. rT45append((T0 *)ms481);
  439. /*UT*/(T45*)oRBC27eh;
  440. rT45add_type((T0 *)C,(T0 *)ms38);
  441. rT45print_as_error((T45*)oRBC27eh);
  442. }
  443. /*FI*/return R;
  444. }
  445. void rT115mapping_c_in(/*C*/T0* a1){
  446. rT7extend((T7*)a1,'T');
  447. rT2append_in(/*(IRF4*/7/*)*/,a1);
  448. }
  449. T0 * rT115run_class(T115 *C){
  450. T0 * R=NULL;
  451. R=(/*UT*/(T52*)oRBC27small_eiffel,
  452. rT52run_class(rT115run_type(C)));
  453. return R;
  454. }
  455. T0 * rT115smallest_ancestor(T115 *C,T0 * a1){
  456. T0 * R=NULL;
  457. T0 * _rto=NULL;
  458. _rto=XrT58run_type(a1);
  459. /*IF*/if (XrT58is_string(_rto)) {
  460. R=(T0 *)C;
  461. }
  462. else {
  463. rT115fatal_error((T0 *)ms1475);
  464. }
  465. /*FI*/return R;
  466. }
  467. T0 * rT115base_class(T115 *C){
  468. T0 * R=NULL;
  469. R=rT48base_class((T48*)(C)->_base_class_name);
  470. return R;
  471. }
  472. void rT115copy(T115 *C,T0 * a1){
  473. /*IF*//*AF*//*AE*/
  474. memcpy(C,a1,s[C->id]);
  475. /*FI*/}
  476. int rT115is_a_in(T115 *C,T0 * a1,T0 * a2){
  477. int R=0;
  478. T0 * _ct=NULL;
  479. T0 * _t2=NULL;
  480. T0 * _t1=NULL;
  481. /*IF*/if (rT7is_equal((T7*)/*(IRF4*/(T0 *)ms188/*)*/,XrT58written_mark(a1))) {
  482. R=1;
  483. }
  484. else {
  485. _ct=((T260*)a2)->_current_type;
  486. _t1=rT115to_runnable(C,_ct);
  487. _t2=XrT58to_runnable(a1,_ct);
  488. /*IF*/if (rT7is_equal((T7*)XrT58run_time_mark(_t1),XrT58run_time_mark(_t2))) {
  489. R=1;
  490. }
  491. else {
  492. R=XrT58is_a(_t1,_t2);
  493. }
  494. /*FI*/}
  495. /*FI*/return R;
  496. }
  497. int rT115is_a(T115 *C,T0 * a1){
  498. int R=0;
  499. /*IF*/if (XrT58is_string(a1)) {
  500. R=1;
  501. }
  502. else {
  503. R=rT50is_subclass_of((T50*)rT115base_class(C),XrT58base_class(a1));
  504. }
  505. /*FI*//*IF*/if (!(R)) {
  506. /*UT*/(T45*)oRBC27eh;
  507. rT45add_type((T0 *)C,(T0 *)ms1483);
  508. /*UT*/(T45*)oRBC27eh;
  509. rT45add_type(a1,(T0 *)ms38);
  510. }
  511. /*FI*/return R;
  512. }
  513. void rT115expanded_to_reference(T115 *C){
  514. /*IF*/if (((T0 *)rT115run_type(C))!=((T0 *)C)) {
  515. XrT58expanded_to_reference(rT115run_type(C));
  516. }
  517. /*AF*//*FI*/}
  518. int rT115has_creation(T115 *C,T0 * a1){
  519. int R=0;
  520. R=rT50has_creation((T50*)rT115base_class(C),a1);
  521. return R;
  522. }
  523. int ofBC115check_type=0;
  524. void rT115check_type(T115 *C){
  525. T0 * _rc=NULL;
  526. T0 * _bc=NULL;
  527. int _ne=0;
  528. if (ofBC115check_type==0){
  529. ofBC115check_type=1;
  530. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  531. _bc=rT115base_class(C);
  532. /*IF*/if (!(_bc)) {
  533. rT115error(rT115start_position(C),(T0 *)ms1457);
  534. }
  535. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  536. _rc=rT115run_class(C);
  537. }
  538. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  539. /*IF*/if (((T50*)_bc)->_is_expanded) {
  540. rT115error(rT115start_position(C),(T0 *)ms1458);
  541. }
  542. /*FI*/}
  543. /*FI*/}
  544. }
  545. void rT115make(T115 *C,T0 * a1){
  546. {T48 *n=((T48*)new(48));
  547. rT48make(n,(T0 *)ms188,a1);
  548. C->_base_class_name=(T0 *)n;}
  549. }
  550. void rT115c_type_in(/*C*/T0* a1){
  551. rT7append((T7*)a1,(T0 *)ms764);
  552. }
  553. T0 * rT116type_any(/*C*/void){
  554. T0 * R=NULL;
  555. if (ofBC27type_any==0){
  556. ofBC27type_any=1;
  557. {T87 *n=((T87*)new(87));
  558. rT87make(n,NULL);
  559. R=(T0 *)n;}
  560. oRBC27type_any=R;}
  561. return oRBC27type_any;}
  562. void rT116c_initialize_expanded(T116 *C){
  563. T0 * _rf=NULL;
  564. int _i=0;
  565. T0* _wa=NULL;
  566. rT40put_character((T40*)oRBC27cpp,'\173');
  567. _wa=rT260writable_attributes((T260*)rT116run_class(C));
  568. /*IF*/if (((int)_wa)) {
  569. _i=1;
  570. while (!((_i)>(XrT265upper(_wa)))) {
  571. _rf=XrT265item(_wa,_i);
  572. XrT58c_initialize(XrT261result_type(_rf));
  573. _i=(_i)+(1);
  574. /*IF*/if ((_i)<=(XrT265upper(_wa))) {
  575. rT40put_character((T40*)oRBC27cpp,'\54');
  576. }
  577. /*FI*/}
  578. }
  579. /*FI*/rT40put_character((T40*)oRBC27cpp,'\175');
  580. }
  581. void rT116c_initialize(T116 *C){
  582. /*IF*/if (rT116is_expanded(C)) {
  583. rT116c_initialize_expanded(C);
  584. }
  585. else {
  586. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1409);
  587. }
  588. /*FI*/}
  589. T0* rT116run_time_mark(T116 *C){
  590. T0* R=NULL;
  591. R=((T48*)(C)->_base_class_name)->_to_string;
  592. return R;
  593. }
  594. void rT116fatal_error(/*C*/T0* a1){
  595. rT45fatal_error((T45*)oRBC27eh,a1);
  596. }
  597. T0 * rT116run_type(T116 *C){
  598. T0 * R=NULL;
  599. R=(T0 *)C;
  600. return R;
  601. }
  602. T0 * rT116to_runnable(T116 *C,T0 * a1){
  603. T0 * R=NULL;
  604. T0 * _rc=NULL;
  605. T0 * _bc=NULL;
  606. _bc=rT48base_class((T48*)(C)->_base_class_name);
  607. /*IF*/if (((T50*)_bc)->_is_expanded) {
  608. /*IF*/if (!(rT56fast_has((T56*)oRBC116check_memory,_bc))) {
  609. rT50check_expanded_with((T50*)_bc,(T0 *)C);
  610. rT56add_last((T56*)oRBC116check_memory,_bc);
  611. }
  612. /*FI*/}
  613. /*FI*/_rc=rT116run_class(C);
  614. R=(T0 *)C;
  615. return R;
  616. }
  617. void rT116cast_to_ref(T116 *C){
  618. XrT58cast_to_ref(rT116run_type(C));
  619. }
  620. void rT116error(/*C*/T0 * a1,T0* a2){
  621. /*UT*/(T45*)oRBC27eh;
  622. rT45add_position(a1);
  623. rT45error((T45*)oRBC27eh,a2);
  624. }
  625. int rT116id(T116 *C){
  626. int R=0;
  627. R=((T50*)rT116base_class(C))->_id;
  628. return R;
  629. }
  630. T0 * rT116start_position(T116 *C){
  631. T0 * R=NULL;
  632. R=((T48*)(C)->_base_class_name)->_start_position;
  633. return R;
  634. }
  635. T0* rT116generic_list(T116 *C){
  636. T0* R=NULL;
  637. /*UT*/(T45*)oRBC27eh;
  638. rT45add_type((T0 *)C,(T0 *)ms1437);
  639. rT45print_as_fatal_error((T45*)oRBC27eh);
  640. return R;
  641. }
  642. int rT116is_reference(T116 *C){
  643. int R=0;
  644. T0 * _bc=NULL;
  645. _bc=rT116base_class(C);
  646. /*IF*/if (!(_bc)) {
  647. rT116error(rT116start_position(C),(T0 *)ms1460);
  648. }
  649. else {
  650. R=!(((T50*)_bc)->_is_expanded);
  651. }
  652. /*FI*/return R;
  653. }
  654. T0 * rT116look_up_for(T116 *C,T0 * a1,T0 * a2){
  655. T0 * R=NULL;
  656. T0 * _bc=NULL;
  657. _bc=rT116base_class(C);
  658. /*IF*/if (((int)_bc)) {
  659. R=rT50look_up_for((T50*)_bc,a1,a2);
  660. }
  661. else {
  662. /*UT*/(T45*)oRBC27eh;
  663. rT45append((T0 *)ms481);
  664. /*UT*/(T45*)oRBC27eh;
  665. rT45add_type((T0 *)C,(T0 *)ms38);
  666. rT45print_as_error((T45*)oRBC27eh);
  667. }
  668. /*FI*/return R;
  669. }
  670. void rT116mapping_c_in(T116 *C,T0* a1){
  671. rT7extend((T7*)a1,'T');
  672. rT2append_in(rT116id(C),a1);
  673. }
  674. void rT116mapping_cast(T116 *C){
  675. rT7copy((T7*)oRBC58tmp_string,(T0 *)ms800);
  676. rT2append_in(rT116id(C),oRBC58tmp_string);
  677. /*IF*/if (rT116is_reference(C)) {
  678. rT7extend((T7*)oRBC58tmp_string,'\52');
  679. }
  680. /*FI*/rT7extend((T7*)oRBC58tmp_string,'\51');
  681. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  682. }
  683. T0 * rT116run_class(T116 *C){
  684. T0 * R=NULL;
  685. R=(/*UT*/(T52*)oRBC27small_eiffel,
  686. rT52run_class(rT116run_type(C)));
  687. return R;
  688. }
  689. int rT116is_expanded(T116 *C){
  690. int R=0;
  691. T0 * _bc=NULL;
  692. _bc=rT116base_class(C);
  693. /*IF*/if (!(_bc)) {
  694. rT116error(rT116start_position(C),(T0 *)ms476);
  695. }
  696. else {
  697. R=((T50*)_bc)->_is_expanded;
  698. }
  699. /*FI*/return R;
  700. }
  701. T0 * rT116smallest_ancestor(T116 *C,T0 * a1){
  702. T0 * R=NULL;
  703. T0 * _pl2=NULL;
  704. T0 * _pl1=NULL;
  705. T0 * _rto=NULL;
  706. _rto=XrT58run_type(a1);
  707. /*IF*/if (XrT58is_none(a1)) {
  708. R=(T0 *)C;
  709. }
  710.  else if (XrT58is_any(_rto)) {
  711. R=a1;
  712. }
  713.  else if (((T0 *)XrT58base_class(a1))==((T0 *)rT116base_class(C))) {
  714. R=(T0 *)C;
  715. }
  716. else {
  717. _pl1=((T50*)rT116base_class(C))->_parent_list;
  718. _pl2=((T50*)XrT58base_class(_rto))->_parent_list;
  719. /*IF*/if ((!(_pl1))&&(!(_pl2))) {
  720. R=rT116type_any();
  721. }
  722.  else if (!(_pl1)) {
  723. /*IF*/if ((rT131count((T131*)_pl2))==(1)) {
  724. R=XrT58smallest_ancestor(((T118*)rT131super((T131*)_pl2))->_type,(T0 *)C);
  725. }
  726. else {
  727. rT116fatal_error((T0 *)ms1468);
  728. }
  729. /*FI*/}
  730.  else if (!(_pl2)) {
  731. /*IF*/if ((rT131count((T131*)_pl1))==(1)) {
  732. R=XrT58smallest_ancestor(((T118*)rT131super((T131*)_pl1))->_type,a1);
  733. }
  734. else {
  735. rT116fatal_error((T0 *)ms1469);
  736. }
  737. /*FI*/}
  738.  else if (((rT131count((T131*)_pl1))==(1))&&((rT131count((T131*)_pl2))==(1))) {
  739. R=XrT58smallest_ancestor(((T118*)rT131super((T131*)_pl1))->_type,((T118*)rT131super((T131*)_pl2))->_type);
  740. }
  741. else {
  742. rT116fatal_error((T0 *)ms1470);
  743. }
  744. /*FI*/}
  745. /*FI*/return R;
  746. }
  747. T0* rT116written_mark(T116 *C){
  748. T0* R=NULL;
  749. R=((T48*)(C)->_base_class_name)->_to_string;
  750. return R;
  751. }
  752. T0 * rT116base_class(T116 *C){
  753. T0 * R=NULL;
  754. R=rT48base_class((T48*)(C)->_base_class_name);
  755. return R;
  756. }
  757. void rT116copy(T116 *C,T0 * a1){
  758. /*IF*//*AF*//*AE*/
  759. memcpy(C,a1,s[C->id]);
  760. /*FI*/}
  761. int rT116is_a_in(T116 *C,T0 * a1,T0 * a2){
  762. int R=0;
  763. T0 * _ct=NULL;
  764. T0 * _t2=NULL;
  765. T0 * _t1=NULL;
  766. /*IF*/if (rT7is_equal((T7*)rT116written_mark(C),XrT58written_mark(a1))) {
  767. R=1;
  768. }
  769. else {
  770. _ct=((T260*)a2)->_current_type;
  771. _t1=rT116to_runnable(C,_ct);
  772. _t2=XrT58to_runnable(a1,_ct);
  773. /*IF*/if (rT7is_equal((T7*)XrT58run_time_mark(_t1),XrT58run_time_mark(_t2))) {
  774. R=1;
  775. }
  776. else {
  777. R=XrT58is_a(_t1,_t2);
  778. }
  779. /*FI*/}
  780. /*FI*/return R;
  781. }
  782. void rT116c_struct(T116 *C){
  783. T0* _wa=NULL;
  784. T0 * _a=NULL;
  785. int _i=0;
  786. /*(IRF3*/(((T7*)oRBC58tmp_string)->_count)=(0);
  787. /*)*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms762);
  788. rT2append_in(rT116id(C),oRBC58tmp_string);
  789. rT7extend((T7*)oRBC58tmp_string,'\173');
  790. /*IF*/if (rT116is_reference(C)) {
  791. rT7append((T7*)oRBC58tmp_string,(T0 *)ms763);
  792. }
  793. /*FI*/_wa=rT260writable_attributes((T260*)rT116run_class(C));
  794. /*IF*/if (((int)_wa)) {
  795. _i=XrT265lower(_wa);
  796. while (!((_i)>(XrT265upper(_wa)))) {
  797. _a=XrT265item(_wa,_i);
  798. XrT58c_type_in(XrT58run_type(XrT261result_type(_a)),oRBC58tmp_string);
  799. rT7append((T7*)oRBC58tmp_string,(T0 *)ms765);
  800. rT7append((T7*)oRBC58tmp_string,XrT67to_string(XrT261name(_a)));
  801. rT7extend((T7*)oRBC58tmp_string,'\73');
  802. _i=(_i)+(1);
  803. }
  804. }
  805. /*FI*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms766);
  806. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  807. }
  808. int rT116is_a(T116 *C,T0 * a1){
  809. int R=0;
  810. T0 * _other_bc=NULL;
  811. _other_bc=XrT58base_class(a1);
  812. /*IF*/if (((T0 *)rT116base_class(C))==((T0 *)_other_bc)) {
  813. R=1;
  814. }
  815.  else if (!(_other_bc)) {
  816. }
  817.  else if (rT50is_subclass_of((T50*)rT116base_class(C),_other_bc)) {
  818. /*IF*/if (XrT58is_generic(a1)) {
  819. R=rT131is_a((T131*)((T50*)rT116base_class(C))->_parent_list,a1);
  820. }
  821. else {
  822. R=1;
  823. }
  824. /*FI*/}
  825. /*FI*//*IF*/if (!(R)) {
  826. /*UT*/(T45*)oRBC27eh;
  827. rT45add_type((T0 *)C,(T0 *)ms1483);
  828. /*UT*/(T45*)oRBC27eh;
  829. rT45add_type(a1,(T0 *)ms38);
  830. }
  831. /*FI*/return R;
  832. }
  833. void rT116expanded_to_reference(T116 *C){
  834. /*IF*/if (((T0 *)rT116run_type(C))!=((T0 *)C)) {
  835. XrT58expanded_to_reference(rT116run_type(C));
  836. }
  837.  else if (rT116is_expanded(C)) {
  838. /*UT*/(T45*)oRBC27eh;
  839. rT45add_type((T0 *)C,(T0 *)ms1007);
  840. rT116fatal_error((T0 *)ms1008);
  841. }
  842. /*FI*/}
  843. int rT116has_creation(T116 *C,T0 * a1){
  844. int R=0;
  845. R=rT50has_creation((T50*)rT116base_class(C),a1);
  846. return R;
  847. }
  848. T0*oRBC116check_memory;
  849. void rT116c_typedef(T116 *C){
  850. int _mem_id=0;
  851. _mem_id=rT116id(C);
  852. /*(IRF3*/(((T7*)oRBC58tmp_string)->_count)=(0);
  853. /*)*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms755);
  854. rT2append_in(rT116id(C),oRBC58tmp_string);
  855. rT7append((T7*)oRBC58tmp_string,(T0 *)ms756);
  856. rT2append_in(rT116id(C),oRBC58tmp_string);
  857. rT7append((T7*)oRBC58tmp_string,(T0 *)ms757);
  858. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  859. }
  860. void rT116c_type_in(T116 *C,T0* a1){
  861. /*IF*/if (rT116is_reference(C)) {
  862. rT7append((T7*)a1,(T0 *)ms1501);
  863. }
  864. else {
  865. rT7extend((T7*)a1,'T');
  866. rT2append_in(rT116id(C),a1);
  867. }
  868. /*FI*/}
  869. int rT117is_run_type(T117 *C){
  870. int R=0;
  871. R=((int)(C)->_run_type);
  872. return R;
  873. }
  874. T0* rT117run_time_mark(T117 *C){
  875. T0* R=NULL;
  876. R=((T117*)(C)->_run_type)->_written_mark;
  877. return R;
  878. }
  879. void rT117fatal_error(/*C*/T0* a1){
  880. rT45fatal_error((T45*)oRBC27eh,a1);
  881. }
  882. T0 * rT117to_runnable(T117 *C,T0 * a1){
  883. T0 * R=NULL;
  884. T0* _rgl=NULL;
  885. T0 * _t=NULL;
  886. int _i=0;
  887. /*IF*/if (((T0 *)(C)->_run_type)==((T0 *)C)) {
  888. R=(T0 *)C;
  889. }
  890.  else if (!((C)->_run_type)) {
  891. {T106 *n=((T106*)new(106));
  892. rT106make(n,1,rT106count((T106*)(C)->_generic_list));
  893. _rgl=(T0 *)n;}
  894. _i=1;
  895. while (!((_i)>(((T106*)_rgl)->_upper))) {
  896. _t=XrT58to_runnable(rT106item((T106*)(C)->_generic_list,_i),a1);
  897. /*IF*/if ((!(_t))||(!(XrT58is_run_type(_t)))) {
  898. /*UT*/(T45*)oRBC27eh;
  899. rT45add_type(rT106item((T106*)(C)->_generic_list,_i),(T0 *)ms1431);
  900. rT45print_as_error((T45*)oRBC27eh);
  901. _i=(((T106*)_rgl)->_upper)+(1);
  902. }
  903. else {
  904. rT106put((T106*)_rgl,XrT58run_type(_t),_i);
  905. _i=(_i)+(1);
  906. }
  907. /*FI*/}
  908. /*IF*/if ((_i)>(((T106*)_rgl)->_upper)) {
  909. {T117 *n=((T117*)new(117));
  910. rT117make(n,(C)->_base_class_name,_rgl);
  911. C->_run_type=(T0 *)n;}
  912. R=(C)->_run_type;
  913. }
  914. else {
  915. rT117error(rT117start_position(C),(T0 *)ms1459);
  916. }
  917. /*FI*/}
  918. else {
  919. R=rT117to_runnable((T117*)rT117clone(C,(T0 *)C),a1);
  920. }
  921. /*FI*/return R;
  922. }
  923. void rT117cast_to_ref(T117 *C){
  924. rT117cast_to_ref((T117*)(C)->_run_type);
  925. }
  926. void rT117error(/*C*/T0 * a1,T0* a2){
  927. /*UT*/(T45*)oRBC27eh;
  928. rT45add_position(a1);
  929. rT45error((T45*)oRBC27eh,a2);
  930. }
  931. int rT117id(T117 *C){
  932. int R=0;
  933. R=((T260*)rT117run_class(C))->_id;
  934. return R;
  935. }
  936. T0 * rT117start_position(T117 *C){
  937. T0 * R=NULL;
  938. R=((T48*)(C)->_base_class_name)->_start_position;
  939. return R;
  940. }
  941. T0* rT117clone(T117 *C,T0* a1){
  942. T0* R=NULL;
  943. /*IF*/if (((int)a1)) {
  944. R=(T0 *)new(a1->id);
  945. AF_1
  946. XrT28copy(R,a1);
  947. AF_0
  948. }
  949. /*FI*/return R;
  950. }
  951. T0 * rT117look_up_for(T117 *C,T0 * a1,T0 * a2){
  952. T0 * R=NULL;
  953. T0 * _bc=NULL;
  954. _bc=rT117base_class(C);
  955. /*IF*/if (((int)_bc)) {
  956. R=rT50look_up_for((T50*)_bc,a1,a2);
  957. }
  958. else {
  959. /*UT*/(T45*)oRBC27eh;
  960. rT45append((T0 *)ms481);
  961. /*UT*/(T45*)oRBC27eh;
  962. rT45add_type((T0 *)C,(T0 *)ms38);
  963. rT45print_as_error((T45*)oRBC27eh);
  964. }
  965. /*FI*/return R;
  966. }
  967. void rT117mapping_c_in(T117 *C,T0* a1){
  968. rT7extend((T7*)a1,'T');
  969. rT2append_in(rT117id(C),a1);
  970. }
  971. void rT117mapping_cast(T117 *C){
  972. rT7copy((T7*)oRBC58tmp_string,(T0 *)ms800);
  973. rT2append_in(rT117id(C),oRBC58tmp_string);
  974. /*IF*/{/*AT*/rT7extend((T7*)oRBC58tmp_string,'\52');
  975. }
  976. /*FI*/rT7extend((T7*)oRBC58tmp_string,'\51');
  977. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  978. }
  979. T0 * rT117run_class(T117 *C){
  980. T0 * R=NULL;
  981. R=(/*UT*/(T52*)oRBC27small_eiffel,
  982. rT52run_class((C)->_run_type));
  983. return R;
  984. }
  985. int rT117is_expanded(T117 *C){
  986. int R=0;
  987. T0 * _bc=NULL;
  988. _bc=rT117base_class(C);
  989. /*IF*/if (!(_bc)) {
  990. rT117error(rT117start_position(C),(T0 *)ms476);
  991. }
  992. else {
  993. R=((T50*)_bc)->_is_expanded;
  994. }
  995. /*FI*/return R;
  996. }
  997. T0 * rT117smallest_ancestor(/*C*/T0 * a1){
  998. T0 * R=NULL;
  999. rT117fatal_error((T0 *)ms1476);
  1000. return R;
  1001. }
  1002. T0 * rT117base_class(T117 *C){
  1003. T0 * R=NULL;
  1004. R=rT48base_class((T48*)(C)->_base_class_name);
  1005. return R;
  1006. }
  1007. void rT117copy(T117 *C,T0 * a1){
  1008. C->_base_class_name=((T117*)a1)->_base_class_name;
  1009. C->_written_mark=((T117*)a1)->_written_mark;
  1010. C->_generic_list=rT117clone(C,((T117*)a1)->_generic_list);
  1011. }
  1012. int rT117is_a_in(T117 *C,T0 * a1,T0 * a2){
  1013. int R=0;
  1014. T0 * _ct=NULL;
  1015. T0 * _t2=NULL;
  1016. T0 * _t1=NULL;
  1017. /*IF*/if (rT7is_equal((T7*)(C)->_written_mark,XrT58written_mark(a1))) {
  1018. R=1;
  1019. }
  1020. else {
  1021. _ct=((T260*)a2)->_current_type;
  1022. _t1=rT117to_runnable(C,_ct);
  1023. _t2=XrT58to_runnable(a1,_ct);
  1024. /*IF*/if (rT7is_equal((T7*)XrT58run_time_mark(_t1),XrT58run_time_mark(_t2))) {
  1025. R=1;
  1026. }
  1027. else {
  1028. R=XrT58is_a(_t1,_t2);
  1029. }
  1030. /*FI*/}
  1031. /*FI*/return R;
  1032. }
  1033. void rT117c_struct(T117 *C){
  1034. T0* _wa=NULL;
  1035. T0 * _a=NULL;
  1036. int _i=0;
  1037. /*(IRF3*/(((T7*)oRBC58tmp_string)->_count)=(0);
  1038. /*)*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms762);
  1039. rT2append_in(rT117id(C),oRBC58tmp_string);
  1040. rT7extend((T7*)oRBC58tmp_string,'\173');
  1041. /*IF*/{/*AT*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms763);
  1042. }
  1043. /*FI*/_wa=rT260writable_attributes((T260*)rT117run_class(C));
  1044. /*IF*/if (((int)_wa)) {
  1045. _i=XrT265lower(_wa);
  1046. while (!((_i)>(XrT265upper(_wa)))) {
  1047. _a=XrT265item(_wa,_i);
  1048. XrT58c_type_in(XrT58run_type(XrT261result_type(_a)),oRBC58tmp_string);
  1049. rT7append((T7*)oRBC58tmp_string,(T0 *)ms765);
  1050. rT7append((T7*)oRBC58tmp_string,XrT67to_string(XrT261name(_a)));
  1051. rT7extend((T7*)oRBC58tmp_string,'\73');
  1052. _i=(_i)+(1);
  1053. }
  1054. }
  1055. /*FI*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms766);
  1056. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  1057. }
  1058. int rT117is_a(T117 *C,T0 * a1){
  1059. int R=0;
  1060. T0 * _t2=NULL;
  1061. T0 * _t1=NULL;
  1062. int _i=0;
  1063. /*IF*/if (XrT58is_none(a1)) {
  1064. }
  1065.  else if (XrT58is_pointer(a1)) {
  1066. }
  1067.  else if (((T0 *)rT117run_class(C))==((T0 *)XrT58run_class(a1))) {
  1068. R=1;
  1069. }
  1070.  else if ((XrT58is_generic(a1))&&(((T0 *)rT117base_class(C))==((T0 *)XrT58base_class(a1)))) {
  1071. R=1;
  1072. _i=((T106*)(C)->_generic_list)->_upper;
  1073. while (!((!(R))||((_i)==(0)))) {
  1074. _t1=XrT58run_type(rT106item((T106*)(C)->_generic_list,_i));
  1075. _t2=XrT58run_type(rT106item((T106*)XrT58generic_list(a1),_i));
  1076. /*IF*/if (XrT58is_a(_t1,_t2)) {
  1077. _i=(_i)-(1);
  1078. }
  1079. else {
  1080. R=0;
  1081. /*UT*/(T45*)oRBC27eh;
  1082. rT45append((T0 *)ms1438);
  1083. }
  1084. /*FI*/}
  1085. /*IF*/if (!(R)) {
  1086. /*UT*/(T45*)oRBC27eh;
  1087. rT45add_type((T0 *)C,(T0 *)ms1483);
  1088. /*UT*/(T45*)oRBC27eh;
  1089. rT45add_type(a1,(T0 *)ms1488);
  1090. }
  1091. /*FI*/}
  1092.  else if (((XrT58is_generic(a1))&&(rT50is_subclass_of((T50*)rT117base_class(C),XrT58base_class(a1))))&&((rT106count((T106*)XrT58generic_list(a1)))==(rT106count((T106*)(C)->_generic_list)))) {
  1093. R=1;
  1094. _i=((T106*)(C)->_generic_list)->_upper;
  1095. while (!((!(R))||((_i)==(0)))) {
  1096. _t1=XrT58run_type(rT106item((T106*)(C)->_generic_list,_i));
  1097. _t2=XrT58run_type(rT106item((T106*)XrT58generic_list(a1),_i));
  1098. /*IF*/if (XrT58is_a(_t1,_t2)) {
  1099. _i=(_i)-(1);
  1100. }
  1101. else {
  1102. R=0;
  1103. /*UT*/(T45*)oRBC27eh;
  1104. rT45append((T0 *)ms1438);
  1105. }
  1106. /*FI*/}
  1107. /*IF*/if (!(R)) {
  1108. /*UT*/(T45*)oRBC27eh;
  1109. rT45add_type((T0 *)C,(T0 *)ms1483);
  1110. /*UT*/(T45*)oRBC27eh;
  1111. rT45add_type(a1,(T0 *)ms1489);
  1112. }
  1113. /*FI*/}
  1114.  else if ((!(XrT58is_generic(a1)))&&(rT50is_subclass_of((T50*)rT117base_class(C),XrT58base_class(a1)))) {
  1115. R=1;
  1116. }
  1117. else {
  1118. /*UT*/(T45*)oRBC27eh;
  1119. rT45add_type((T0 *)C,(T0 *)ms1483);
  1120. /*UT*/(T45*)oRBC27eh;
  1121. rT45add_type(a1,(T0 *)ms1490);
  1122. }
  1123. /*FI*/return R;
  1124. }
  1125. void rT117expanded_to_reference(T117 *C){
  1126. /*IF*/if (((T0 *)(C)->_run_type)!=((T0 *)C)) {
  1127. rT117expanded_to_reference((T117*)(C)->_run_type);
  1128. }
  1129.  else if (rT117is_expanded(C)) {
  1130. /*UT*/(T45*)oRBC27eh;
  1131. rT45add_type((T0 *)C,(T0 *)ms1007);
  1132. rT117fatal_error((T0 *)ms1008);
  1133. }
  1134. /*FI*/}
  1135. int rT117has_creation(T117 *C,T0 * a1){
  1136. int R=0;
  1137. /*IF*/if (((T0 *)C)==((T0 *)(C)->_run_type)) {
  1138. R=rT50has_creation((T50*)rT117base_class(C),a1);
  1139. }
  1140. else {
  1141. R=rT117has_creation((T117*)(C)->_run_type,a1);
  1142. }
  1143. /*FI*/return R;
  1144. }
  1145. void rT117make(T117 *C,T0 * a1,T0* a2){
  1146. int _is_run=0;
  1147. T0 * _t=NULL;
  1148. int _i=0;
  1149. C->_base_class_name=a1;
  1150. C->_generic_list=a2;
  1151. _is_run=1;
  1152. {T7 *n=((T7*)new(7));
  1153. rT7copy(n,((T48*)a1)->_to_string);
  1154. C->_written_mark=(T0 *)n;}
  1155. rT7extend((T7*)(C)->_written_mark,'\133');
  1156. _i=1;
  1157. while (!((_i)>(((T106*)a2)->_upper))) {
  1158. _t=rT106item((T106*)(C)->_generic_list,_i);
  1159. rT7append((T7*)(C)->_written_mark,XrT58written_mark(_t));
  1160. _is_run=(_is_run)&&(((T0 *)XrT58run_type(_t))==((T0 *)_t));
  1161. _i=(_i)+(1);
  1162. /*IF*/if ((_i)<=(((T106*)a2)->_upper)) {
  1163. rT7extend((T7*)(C)->_written_mark,'\54');
  1164. }
  1165. /*FI*/}
  1166. rT7extend((T7*)(C)->_written_mark,'\135');
  1167. /*IF*/if (_is_run) {
  1168. C->_run_type=(T0 *)C;
  1169. }
  1170. /*FI*/}
  1171. void rT117c_typedef(T117 *C){
  1172. int _mem_id=0;
  1173. _mem_id=rT117id(C);
  1174. /*(IRF3*/(((T7*)oRBC58tmp_string)->_count)=(0);
  1175. /*)*/rT7append((T7*)oRBC58tmp_string,(T0 *)ms755);
  1176. rT2append_in(rT117id(C),oRBC58tmp_string);
  1177. rT7append((T7*)oRBC58tmp_string,(T0 *)ms756);
  1178. rT2append_in(rT117id(C),oRBC58tmp_string);
  1179. rT7append((T7*)oRBC58tmp_string,(T0 *)ms757);
  1180. rT40put_string((T40*)oRBC27cpp,oRBC58tmp_string);
  1181. }
  1182. void rT117c_type_in(T117 *C,T0* a1){
  1183. /*IF*/{/*AT*/rT7append((T7*)a1,(T0 *)ms1502);
  1184. }
  1185. /*FI*/}
  1186. int rT267use_current(T267 *C){
  1187. int R=0;
  1188. int _i=0;
  1189. _i=1;
  1190. while (!((R)||((_i)>(((T268*)(C)->_list)->_upper)))) {
  1191. R=rT137use_current((T137*)rT268item((T268*)(C)->_list,_i));
  1192. _i=(_i)+(1);
  1193. }
  1194. return R;
  1195. }
  1196. void rT267compile_to_c(T267 *C){
  1197. int _i=0;
  1198. /*IF*/if ((((T268*)(C)->_list)->_upper)==(1)) {
  1199. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1379);
  1200. rT137compile_to_c((T137*)rT268first((T268*)(C)->_list));
  1201. }
  1202. else {
  1203. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1381);
  1204. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1382);
  1205. rT137compile_to_c((T137*)rT268first((T268*)(C)->_list));
  1206. _i=1;
  1207. while (!((_i)>(((T268*)(C)->_list)->_upper))) {
  1208. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1383);
  1209. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1384);
  1210. rT137compile_to_c((T137*)rT268item((T268*)(C)->_list,_i));
  1211. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1385);
  1212. _i=(_i)+(1);
  1213. /*IF*/if ((_i)==(((T268*)(C)->_list)->_upper)) {
  1214. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1386);
  1215. }
  1216. /*FI*/}
  1217. }
  1218. /*FI*/}
  1219. void rT267copy(T267 *C,T0 * a1){
  1220. /*IF*//*AF*//*AE*/
  1221. memcpy(C,a1,s[C->id]);
  1222. /*FI*/}
  1223. void rT60fatal_error(/*C*/T0* a1){
  1224. rT45fatal_error((T45*)oRBC27eh,a1);
  1225. }
  1226. T0*oRBC60storage;
  1227. void rT60storage_grow(/*C*/int a1){
  1228. int _i=0;
  1229. T0* _str=NULL;
  1230. _i=((T41*)oRBC60storage)->_upper;
  1231. rT41resize((T41*)oRBC60storage,1,(((T41*)oRBC60storage)->_upper)+(a1));
  1232. while (!((_i)==(((T41*)oRBC60storage)->_upper))) {
  1233. _i=(_i)+(1);
  1234. {T7 *n=((T7*)new(7));
  1235. rT7make(n,80);
  1236. _str=(T0 *)n;}
  1237. rT41put((T41*)oRBC60storage,_str,_i);
  1238. }
  1239. }
  1240. int ofBC60sfr=0;
  1241. T0*oRBC60sfr;
  1242. T0 * rT60sfr(/*C*/void){
  1243. T0 * R=NULL;
  1244. if (ofBC60sfr==0){
  1245. ofBC60sfr=1;
  1246. {T39 *n=((T39*)new(39));
  1247. /*(IRF3*/((n)->_mode)=((T0 *)ms26);
  1248. /*)*/R=(T0 *)n;}
  1249. oRBC60sfr=R;}
  1250. return oRBC60sfr;}
  1251. T0* rT60item(/*C*/int a1){
  1252. T0* R=NULL;
  1253. R=rT41item((T41*)oRBC60storage,a1);
  1254. return R;
  1255. }
  1256. int ofBC60init_storage=0;
  1257. void rT60init_storage(/*C*/void){
  1258. if (ofBC60init_storage==0){
  1259. ofBC60init_storage=1;
  1260. rT60storage_grow(3000);
  1261. }
  1262. }
  1263. void rT60copy(T60 *C,T0 * a1){
  1264. /*IF*//*AF*//*AE*/
  1265. memcpy(C,a1,s[C->id]);
  1266. /*FI*/}
  1267. void rT60read(T60 *C,T0* a1){
  1268. rT60init_storage();
  1269. rT39connect_to((T39*)rT60sfr(),a1);
  1270. /*IF*/if (rT39is_connected((T39*)rT60sfr())) {
  1271. C->_count=0;
  1272. while (!(rT39end_of_input((T39*)rT60sfr()))) {
  1273. C->_count=((C)->_count)+(1);
  1274. /*IF*/if ((((T41*)oRBC60storage)->_upper)<((C)->_count)) {
  1275. rT60storage_grow(1000);
  1276. }
  1277. /*FI*/rT39read_line_in((T39*)rT60sfr(),rT41item((T41*)oRBC60storage,(C)->_count));
  1278. }
  1279. rT39disconnect((T39*)rT60sfr());
  1280. }
  1281. else {
  1282. /*UT*/(T45*)oRBC27eh;
  1283. rT45append((T0 *)ms77);
  1284. /*UT*/(T45*)oRBC27eh;
  1285. rT45append(a1);
  1286. rT60fatal_error((T0 *)ms78);
  1287. }
  1288. /*FI*/}
  1289. T0 * rT170expression(T170 *C,int a1){
  1290. T0 * R=NULL;
  1291. R=XrT81item((C)->_list,a1);
  1292. return R;
  1293. }
  1294. void rT170fatal_error(/*C*/T0* a1){
  1295. rT45fatal_error((T45*)oRBC27eh,a1);
  1296. }
  1297. T0 * rT170first(T170 *C){
  1298. T0 * R=NULL;
  1299. R=rT170expression(C,1);
  1300. return R;
  1301. }
  1302. T0 * rT170to_runnable(T170 *C,T0 * a1){
  1303. T0 * R=NULL;
  1304. T0 * _e2=NULL;
  1305. T0 * _e1=NULL;
  1306. int _i=0;
  1307. int _ne=0;
  1308. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  1309. /*IF*/if (!((C)->_current_type)) {
  1310. C->_current_type=a1;
  1311. _i=1;
  1312. while (!((_i)>(rT170count(C)))) {
  1313. _e1=rT170expression(C,_i);
  1314. _e2=XrT68to_runnable(_e1,(C)->_current_type);
  1315. /*IF*/if (!(_e2)) {
  1316. rT170error(XrT68start_position(_e1),(T0 *)ms1135);
  1317. }
  1318.  else if (((T0 *)_e1)!=((T0 *)_e2)) {
  1319. XrT81put((C)->_list,_e2,_i);
  1320. }
  1321. /*FI*/_i=(_i)+(1);
  1322. }
  1323. /*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  1324. R=(T0 *)C;
  1325. }
  1326. /*FI*/}
  1327.  else if (((T0 *)XrT58run_class(a1))==((T0 *)rT170run_class(C))) {
  1328. R=(T0 *)C;
  1329. }
  1330. else {
  1331. {T170 *n=((T170*)new(170));
  1332. /*(IRF3*/((n)->_list)=(rT170clone(C,(C)->_list));
  1333. /*)*/R=(T0 *)n;}
  1334. R=rT170to_runnable((T170*)R,a1);
  1335. }
  1336. /*FI*/return R;
  1337. }
  1338. int rT170count(T170 *C){
  1339. int R=0;
  1340. R=XrT81upper((C)->_list);
  1341. return R;
  1342. }
  1343. void rT170error(/*C*/T0 * a1,T0* a2){
  1344. /*UT*/(T45*)oRBC27eh;
  1345. rT45add_position(a1);
  1346. rT45error((T45*)oRBC27eh,a2);
  1347. }
  1348. void rT170match_with(T170 *C,T0 * a1){
  1349. T0 * _ot=NULL;
  1350. T0 * _ft=NULL;
  1351. T0 * _at=NULL;
  1352. T0 * _e=NULL;
  1353. int _i=0;
  1354. int _ne=0;
  1355. T0 * _fal=NULL;
  1356. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  1357. _fal=XrT261arguments(a1);
  1358. /*IF*/if (!(_fal)) {
  1359. rT170error(rT170start_position(C),(T0 *)ms1137);
  1360. }
  1361. /*FI*//*IF*/if ((((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0))&&((rT92count((T92*)_fal))!=(rT170count(C)))) {
  1362. /*UT*/(T45*)oRBC27eh;
  1363. rT45add_position(((T92*)_fal)->_start_position);
  1364. rT170error(rT170start_position(C),(T0 *)ms1138);
  1365. }
  1366. /*FI*/_i=1;
  1367. while (!(((_i)>(rT170count(C)))||(((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))>(0)))) {
  1368. _e=rT170expression(C,_i);
  1369. _at=XrT68result_type(_e);
  1370. _ft=rT92type((T92*)_fal,_i);
  1371. /*IF*/if (XrT58is_like_current(_ft)) {
  1372. /*IF*/if (XrT68is_current(_e)) {
  1373. }
  1374.  else if (XrT58is_a(XrT58run_type(_at),XrT58run_type(_ft))) {
  1375. /*IF*/if (XrT58is_expanded(XrT58run_type(_at))) {
  1376. }
  1377.  else if (XrT58is_a(XrT58run_type(_ft),XrT58run_type(_at))) {
  1378. }
  1379. else {
  1380. /*UT*/(T45*)oRBC27eh;
  1381. rT45add_position(XrT68start_position(_e));
  1382. rT170error(XrT58start_position(_ft),(T0 *)ms1139);
  1383. }
  1384. /*FI*/}
  1385. else {
  1386. /*UT*/(T45*)oRBC27eh;
  1387. rT45add_position(XrT68start_position(_e));
  1388. rT170error(XrT58start_position(_ft),(T0 *)ms1139);
  1389. }
  1390. /*FI*/}
  1391.  else if (XrT58is_like_feature(_ft)) {
  1392. /*IF*/if (XrT58is_a(XrT58run_type(_at),XrT58run_type(_ft))) {
  1393. }
  1394. else {
  1395. /*UT*/(T45*)oRBC27eh;
  1396. rT45add_position(XrT68start_position(_e));
  1397. rT170error(XrT58start_position(_ft),(T0 *)ms1140);
  1398. }
  1399. /*FI*/}
  1400.  else if (XrT58is_like_argument(_ft)) {
  1401. _ot=XrT68result_type(rT170expression(C,((T88*)XrT58like_argument(_ft))->_rank));
  1402. /*IF*/if (!(XrT58is_a(XrT58run_type(_at),XrT58run_type(_ot)))) {
  1403. /*UT*/(T45*)oRBC27eh;
  1404. rT45add_position(XrT68start_position(_e));
  1405. rT170error(XrT58start_position(_ft),(T0 *)ms1141);
  1406. }
  1407. /*FI*/}
  1408.  else if (XrT58is_a(XrT58run_type(_at),XrT58run_type(_ft))) {
  1409. }
  1410. else {
  1411. rT45print_as_error((T45*)oRBC27eh);
  1412. /*UT*/(T45*)oRBC27eh;
  1413. rT45add_position(XrT58start_position(_ft));
  1414. rT170error(XrT68start_position(_e),(T0 *)ms1142);
  1415. }
  1416. /*FI*/_at=XrT58run_type(_at);
  1417. _ft=XrT58run_type(_ft);
  1418. /*IF*/if (XrT58is_expanded(_ft)) {
  1419. /*IF*/if (XrT58is_expanded(_at)) {
  1420. }
  1421. else {
  1422. }
  1423. /*FI*/}
  1424. else {
  1425. /*IF*/if (XrT58is_expanded(_at)) {
  1426. XrT58used_as_reference(_at);
  1427. }
  1428. else {
  1429. }
  1430. /*FI*/}
  1431. /*FI*/_i=(_i)+(1);
  1432. }
  1433. }
  1434. T0 * rT170start_position(T170 *C){
  1435. T0 * R=NULL;
  1436. R=XrT68start_position(rT170first(C));
  1437. return R;
  1438. }
  1439. int rT170use_current(T170 *C){
  1440. int R=0;
  1441. int _i=0;
  1442. _i=1;
  1443. while (!(((_i)>(rT170count(C)))||(R))) {
  1444. R=XrT68use_current(rT170expression(C,_i));
  1445. _i=(_i)+(1);
  1446. }
  1447. return R;
  1448. }
  1449. T0* rT170clone(T170 *C,T0* a1){
  1450. T0* R=NULL;
  1451. /*IF*/if (((int)a1)) {
  1452. R=(T0 *)new(a1->id);
  1453. AF_1
  1454. XrT28copy(R,a1);
  1455. AF_0
  1456. }
  1457. /*FI*/return R;
  1458. }
  1459. T0 * rT170run_class(T170 *C){
  1460. T0 * R=NULL;
  1461. R=XrT58run_class((C)->_current_type);
  1462. return R;
  1463. }
  1464. void rT170compile_to_c_old(T170 *C){
  1465. int _i=0;
  1466. /*IF*/if (((int)(C)->_list)) {
  1467. _i=1;
  1468. while (!((_i)>(XrT81upper((C)->_list)))) {
  1469. XrT68compile_to_c_old(XrT81item((C)->_list,_i));
  1470. _i=(_i)+(1);
  1471. }
  1472. }
  1473. /*FI*/}
  1474. void rT170compile_to_c(T170 *C,T0 * a1){
  1475. T0 * _ft=NULL;
  1476. T0 * _at=NULL;
  1477. T0 * _e=NULL;
  1478. int _i=0;
  1479. _i=1;
  1480. while (!((_i)>(rT170count(C)))) {
  1481. _e=rT170expression(C,_i);
  1482. _at=XrT58run_type(XrT68result_type(_e));
  1483. _ft=XrT58run_type(rT92type((T92*)a1,_i));
  1484. /*IF*/if (XrT58is_expanded(_ft)) {
  1485. /*IF*/if (XrT58is_expanded(_at)) {
  1486. XrT68compile_to_c(_e);
  1487. }
  1488. else {
  1489. /*UT*/(T45*)oRBC27eh;
  1490. rT45add_position(XrT68start_position(_e));
  1491. rT170fatal_error((T0 *)ms1184);
  1492. }
  1493. /*FI*/}
  1494. else {
  1495. /*IF*/if (XrT58is_expanded(_at)) {
  1496. XrT58expanded_to_reference(_at);
  1497. rT40put_character((T40*)oRBC27cpp,'\50');
  1498. XrT68compile_to_c(_e);
  1499. rT40put_character((T40*)oRBC27cpp,'\51');
  1500. }
  1501. else {
  1502. /*IF*/if ((XrT68is_current(_e))||(XrT68is_manifest_string(_e))) {
  1503. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1185);
  1504. }
  1505. /*FI*/XrT68compile_to_c(_e);
  1506. }
  1507. /*FI*/}
  1508. /*FI*/_i=(_i)+(1);
  1509. /*IF*/if ((_i)<=(rT170count(C))) {
  1510. rT40put_character((T40*)oRBC27cpp,'\54');
  1511. }
  1512. /*FI*/}
  1513. }
  1514. void rT170copy(T170 *C,T0 * a1){
  1515. /*IF*//*AF*//*AE*/
  1516. memcpy(C,a1,s[C->id]);
  1517. /*FI*/}
  1518. int rT94put_into(T94 *C,T0* a1,int a2){
  1519. int R=0;
  1520. int _rank=0;
  1521. _rank=rT96index_of((T96*)a1,(T0 *)C);
  1522. /*IF*/if ((_rank)<=(((T96*)a1)->_upper)) {
  1523. /*UT*/(T45*)oRBC27eh;
  1524. rT45add_position(rT94start_position(C));
  1525. /*UT*/(T45*)oRBC27eh;
  1526. rT45add_position(rT94start_position((T94*)rT96item((T96*)a1,_rank)));
  1527. rT45error((T45*)oRBC27eh,(T0 *)ms1514);
  1528. }
  1529. /*FI*/rT96put((T96*)a1,(T0 *)C,a2);
  1530. R=(a2)+(1);
  1531. return R;
  1532. }
  1533. T0 * rT94start_position(T94 *C){
  1534. T0 * R=NULL;
  1535. R=((T97*)(C)->_name)->_start_position;
  1536. return R;
  1537. }
  1538. int rT94is_equal(T94 *C,T0 * a1){
  1539. int R=0;
  1540. R=rT7is_equal((T7*)rT97to_key((T97*)(C)->_name),rT97to_key((T97*)((T94*)a1)->_name));
  1541. return R;
  1542. }
  1543. void rT94copy(T94 *C,T0 * a1){
  1544. /*IF*//*AF*//*AE*/
  1545. memcpy(C,a1,s[C->id]);
  1546. /*FI*/}
  1547. void rT94make(T94 *C,T0 * a1,T0 * a2){
  1548. C->_name=a1;
  1549. C->_type=a2;
  1550. }
  1551. int rT142put_into(T142 *C,T0* a1,int a2){
  1552. int R=0;
  1553. T0 * _d1=NULL;
  1554. int _i=0;
  1555. _i=((T141*)(C)->_name_list)->_lower;
  1556. R=a2;
  1557. while (!((_i)>(((T141*)(C)->_name_list)->_upper))) {
  1558. {T94 *n=((T94*)new(94));
  1559. rT94make(n,rT141item((T141*)(C)->_name_list,_i),(C)->_type);
  1560. _d1=(T0 *)n;}
  1561. R=rT94put_into((T94*)_d1,a1,R);
  1562. _i=(_i)+(1);
  1563. }
  1564. return R;
  1565. }
  1566. int rT142count(T142 *C){
  1567. int R=0;
  1568. R=rT141count((T141*)(C)->_name_list);
  1569. return R;
  1570. }
  1571. void rT142copy(T142 *C,T0 * a1){
  1572. /*IF*//*AF*//*AE*/
  1573. memcpy(C,a1,s[C->id]);
  1574. /*FI*/}
  1575. void rT142make(T142 *C,T0* a1,T0 * a2){
  1576. C->_name_list=a1;
  1577. C->_type=a2;
  1578. }
  1579. T0* rT214runnable(T214 *C,T0* a1,T0 * a2,T0 * a3){
  1580. T0* R=NULL;
  1581. T0 * _a=NULL;
  1582. int _i=0;
  1583. /*IF*/if (!(rT158empty((T158*)a1))) {
  1584. R=rT214clone(C,a1);
  1585. _i=1;
  1586. while (!((_i)>(((T158*)R)->_upper))) {
  1587. rT52push((T52*)oRBC27small_eiffel,a3);
  1588. _a=rT64to_runnable((T64*)rT158item((T158*)R,_i),a2);
  1589. /*IF*/if (!(_a)) {
  1590. rT214error(rT64start_position((T64*)rT158item((T158*)R,_i)),(T0 *)ms477);
  1591. }
  1592. else {
  1593. rT158put((T158*)R,_a,_i);
  1594. }
  1595. /*FI*/rT52pop((T52*)oRBC27small_eiffel);
  1596. _i=(_i)+(1);
  1597. }
  1598. }
  1599. /*FI*/return R;
  1600. }
  1601. T0 * rT214to_runnable(T214 *C,T0 * a1){
  1602. T0 * R=NULL;
  1603. /*IF*/if (!((C)->_current_type)) {
  1604. C->_current_type=a1;
  1605. /*IF*/if (((int)(C)->_list)) {
  1606. C->_list=rT214runnable(C,(C)->_list,a1,rT52top_rf((T52*)oRBC27small_eiffel));
  1607. }
  1608. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  1609. R=(T0 *)C;
  1610. }
  1611. /*FI*/}
  1612. else {
  1613. R=rT214clone(C,(T0 *)C);
  1614. /*(IRF3*/(((T214*)R)->_current_type)=(NULL);
  1615. /*)*/R=rT214to_runnable((T214*)R,a1);
  1616. }
  1617. /*FI*/return R;
  1618. }
  1619. void rT214error(/*C*/T0 * a1,T0* a2){
  1620. /*UT*/(T45*)oRBC27eh;
  1621. rT45add_position(a1);
  1622. rT45error((T45*)oRBC27eh,a2);
  1623. }
  1624. int rT214use_current(T214 *C){
  1625. int R=0;
  1626. int _i=0;
  1627. /*IF*/if (((int)(C)->_list)) {
  1628. _i=((T158*)(C)->_list)->_upper;
  1629. while (!((R)||((_i)==(0)))) {
  1630. R=rT64use_current((T64*)rT158item((T158*)(C)->_list,_i));
  1631. _i=(_i)-(1);
  1632. }
  1633. }
  1634. /*FI*/return R;
  1635. }
  1636. T0* rT214clone(T214 *C,T0* a1){
  1637. T0* R=NULL;
  1638. /*IF*/if (((int)a1)) {
  1639. R=(T0 *)new(a1->id);
  1640. AF_1
  1641. XrT28copy(R,a1);
  1642. AF_0
  1643. }
  1644. /*FI*/return R;
  1645. }
  1646.